package db3;

import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 轻量级文件型数据库：文件持久化数据，内存维护表结构和缓存，支持CREATE/INSERT/ALTER/DELETE/UPDATE/DROP/SELECT/SHOW TABLES
 * 存储方式：元数据(metadata.properties)、表数据(data目录下.dat文件，每行一条记录)
 */
public class SimpleDB {
    private static final String DATA_DIR = "data"; // 表数据存储目录
    private static final String METADATA_FILE = "metadata.properties"; // 元数据文件（表结构）
    private Properties metadata; // 内存缓存表结构：key=表名，value=列名+类型（如"id,INT,name,STRING"）
    private Map<String, List<Map<String, Object>>> storage; // 内存缓存表数据：key=表名，value=行列表（每行Map<列名,值>）


    public static void main(String[] args) {
        SimpleDB db = new SimpleDB();
        db.init();
        db.commandLoop();
    }

    /**
     * 初始化：创建内存容器，加载元数据和表数据到内存
     */
    private void init() {
        metadata = new Properties();
        storage = new HashMap<>();
        loadMetadata();
        loadStorage();
    }

    /**
     * 加载元数据：从磁盘文件读取表结构到内存（首次运行文件不存在则容器为空）
     */
    private void loadMetadata() {
        File metaFile = new File(METADATA_FILE);
        if (metaFile.exists()) {
            try (InputStream input = new FileInputStream(metaFile)) {
                metadata.load(input);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 保存元数据：将内存表结构写入磁盘（结构变更后调用）
     */
    private void saveMetadata() {
        try (OutputStream output = new FileOutputStream(METADATA_FILE)) {
            metadata.store(output, null);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 加载表数据：根据元数据读取data目录下.dat文件到内存
     */
    private void loadStorage() {
        File dataDir = new File(DATA_DIR);
        if (!dataDir.exists()) {
            dataDir.mkdir();
        }

        for (String tableName : metadata.stringPropertyNames()) {
            storage.put(tableName, new ArrayList<>());
            File tableFile = new File(dataDir, tableName + ".dat");

            if (tableFile.exists()) {
                try (Scanner scanner = new Scanner(tableFile)) {
                    while (scanner.hasNextLine()) {
                        String line = scanner.nextLine();
                        if (line.trim().isEmpty()) continue;

                        String[] values = line.split(",");
                        Map<String, Object> row = new HashMap<>();
                        String[] columns = metadata.getProperty(tableName).split(",");
                        int expectedColCount = columns.length / 2;

                        if (values.length != expectedColCount) {
                            throw new RuntimeException(
                                    "表[" + tableName + "]数据格式错误：预期" + expectedColCount + "字段，实际" + values.length + "字段（行：" + line + "）"
                            );
                        }

                        for (int i = 0; i < columns.length; i += 2) {
                            String columnName = columns[i];
                            String columnType = columns[i + 1];
                            String rawValue = values[i / 2].trim().replaceAll("^'|'$", "");
                            row.put(columnName, convertValue(rawValue, columnType));
                        }
                        storage.get(tableName).add(row);
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 保存表数据：将内存表数据写入.dat文件（数据变更后调用）
     */
    private void saveStorage() {
        File dataDir = new File(DATA_DIR);
        for (String tableName : storage.keySet()) {
            File tableFile = new File(dataDir, tableName + ".dat");
            try (PrintWriter writer = new PrintWriter(tableFile)) {
                for (Map<String, Object> row : storage.get(tableName)) {
                    List<String> values = new ArrayList<>();
                    String[] columns = metadata.getProperty(tableName).split(","); // 表结构（如["id","INT","name","STRING"]）

                    for (int i = 0; i < columns.length; i += 2) {
                        String columnName = columns[i];
                        Object value = row.get(columnName);
                        String columnType = columns[i + 1];
                        values.add(formatValue(value, columnType));
                    }
                    writer.println(String.join(",", values));
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 工具：将字符串值转换为指定类型（INT→Integer，其他→String）
     */
    private Object convertValue(String value, String type) {
        if ("INT".equalsIgnoreCase(type)) {
            try {
                return Integer.parseInt(value);
            } catch (NumberFormatException e) {
                throw new RuntimeException("INT类型值非法：" + value);
            }
        } else {
            return value;
        }
    }

    /**
     * 工具：格式化内存值为文件存储格式（INT无引号，STRING带单引号）
     */
    private String formatValue(Object value, String type) {
        if (value instanceof Integer && "INT".equalsIgnoreCase(type)) {
            return value.toString();
        } else {
            return "'" + value.toString().replace("'", "''") + "'";
        }
    }

    /**
     * 命令行交互循环：接收并执行SQL命令
     */
    private void commandLoop() {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("SimpleDB> ");
            String sql = scanner.nextLine().trim();

            if (sql.equalsIgnoreCase("EXIT")) {
                break;
            }

            try {
                if (sql.startsWith("CREATE TABLE")) {
                    createTable(sql);
                } else if (sql.startsWith("INSERT INTO")) {
                    insertData(sql);
                } else if (sql.startsWith("ALTER TABLE")) {
                    alterTable(sql);
                } else if (sql.startsWith("DELETE FROM")) {
                    deleteData(sql);
                } else if (sql.startsWith("UPDATE")) {
                    updateData(sql);
                } else if (sql.startsWith("DROP TABLE")) {
                    dropTable(sql);
                } else if (sql.startsWith("SELECT * FROM")) {
                    displayTable(sql);
                } else if (sql.trim().replaceAll(";", "").equalsIgnoreCase("SHOW TABLES")) {
                    showAllTables();
                } else {
                    System.out.println("不支持的命令:  " + sql);
                }
            } catch (Exception e) {
                System.out.println("Error: " + e.getMessage());
            }
        }
        saveChanges();
        scanner.close();
    }

    /**
     * 保存所有变更：持久化元数据和表数据
     */
    private void saveChanges() {
        saveMetadata();
        saveStorage();
    }

    // ======================== 核心SQL操作实现 ========================

    /**
     * 处理CREATE TABLE：创建表并持久化结构
     * 核心流程：
     * 1. 用正则解析SQL，提取表名和列定义
     * 2. 校验表是否已存在（避免重复创建）
     * 3. 解析列定义为"列名,类型"格式的元数据字符串
     * 4. 保存表结构到内存metadata，并初始化空数据列表
     * 5. 持久化元数据到磁盘文件
     */
    private void createTable(String sql) {
        // 正则匹配"CREATE TABLE 表名 (列1 类型1, 列2 类型2...)"
        // 分组1：表名；分组2：括号内的列定义
        Pattern pattern = Pattern.compile(
                "CREATE TABLE (\\w+) \\((.+?)\\)",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);       // 提取表名（如"student"）
            String columnsDef = matcher.group(2);      // 提取列定义（如"id INT, name STRING"）

            // 校验：表已存在则抛异常
            if (metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表已存在: " + tableName);
            }

            // 拆分列定义为单个列（如["id INT", " name STRING"]）
            String[] columns = columnsDef.split(",");
            StringBuilder metaBuilder = new StringBuilder();  // 用于构建元数据字符串

            // 遍历解析每个列的"列名+类型"
            for (int i = 0; i < columns.length; i++) {
                String col = columns[i].trim();  // 去除列前后空格
                String[] parts = col.split("\\s+");  // 按空格分割列名和类型

                // 校验：列定义必须包含列名和类型（如"id INT"）
                if (parts.length < 2) {
                    throw new IllegalArgumentException("非法列定义: " + col);
                }

                // 拼接元数据格式："列名,类型"（如"id,INT"）
                metaBuilder.append(parts[0]).append(",").append(parts[1]);
                if (i != columns.length - 1) {  // 非最后一列加逗号分隔
                    metaBuilder.append(",");
                }
            }

            // 保存表结构到内存元数据
            metadata.setProperty(tableName, metaBuilder.toString());
            // 初始化表数据存储（空列表）
            storage.put(tableName, new ArrayList<>());
            saveMetadata();  // 持久化表结构到磁盘
            System.out.println("表创建成功: " + tableName);
        } else {
            throw new IllegalArgumentException("CREATE TABLE语法错误");
        }
    }

    /**
     * 处理 INSERT INTO：插入记录并持久化
     * 核心流程：
     * 1. 用正则解析SQL，提取表名、列名列表、值列表
     * 2. 校验表是否存在及列数是否匹配表结构
     * 3. 转换值为列定义的类型（INT转Integer，STRING直接使用）
     * 4. 保存记录到内存storage
     * 5. 持久化数据到磁盘文件
     */
    private void insertData(String sql) {
        // 正则匹配"INSERT INTO 表名 (列1,列2) VALUES (值1,值2)"
        // 分组1：表名；分组2：列名列表；分组3：值列表
        Pattern pattern = Pattern.compile(
                "INSERT INTO (\\w+)\\s*\\(([^)]+)\\)\\s*VALUES\\s*\\(([^)]+)\\)",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);       // 表名
            String[] columns = matcher.group(2).split(",");  // 列名数组（如["id", "name"]）
            String[] values = matcher.group(3).split(",");   // 值数组（如["1", "'张三'"]）

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表不存在: " + tableName);
            }

            // 从元数据获取表结构，校验插入列数是否匹配
            String[] columnDefs = metadata.getProperty(tableName).split(",");
            int expectedColCount = columnDefs.length / 2;  // 表的实际列数（元数据长度/2）
            if (columns.length != expectedColCount) {
                throw new IllegalArgumentException("列数不匹配：预期" + expectedColCount + "，实际" + columns.length);
            }

            // 构建行数据Map（键：列名，值：转换后的数据）
            Map<String, Object> row = new HashMap<>();
            for (int i = 0; i < columns.length; i++) {
                String colName = columns[i].trim();    // 列名（去除空格）
                String colType = columnDefs[i * 2 + 1].trim();  // 列类型（元数据中i*2+1位置）
                String val = values[i].trim().replaceAll("^'|'$", "");  // 去除值的首尾单引号

                // 转换值为列定义的类型并放入Map
                row.put(colName, convertValue(val, colType));
            }

            // 添加行数据到内存存储
            storage.get(tableName).add(row);
            saveStorage();  // 持久化数据到磁盘
            System.out.println("数据插入成功: " + tableName);
        } else {
            throw new IllegalArgumentException("INSERT语法错误");
        }
    }

    /**
     * 处理 ALTER TABLE：为表添加新列（仅支持添加）
     * 核心流程：
     * 1. 用正则解析SQL，提取表名、新列名、新列类型
     * 2. 校验表是否存在
     * 3. 更新元数据，在原有结构后追加新列定义
     * 4. 为已有记录添加新列的默认值（INT默认0，STRING默认"DEFAULT"）
     * 5. 持久化更新后的表结构和数据
     */
    private void alterTable(String sql) {
        // 正则匹配"ALTER TABLE 表名 ADD 新列名 类型"
        // 分组1：表名；分组2：新列名；分组3：新列类型
        Pattern pattern = Pattern.compile(
                "ALTER TABLE (\\w+) ADD (\\w+) (\\w+)",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);   // 表名
            String colName = matcher.group(2);     // 新列名
            String colType = matcher.group(3);     // 新列类型

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表不存在: " + tableName);
            }

            // 更新元数据：在原有结构后追加新列"列名,类型"
            String oldMeta = metadata.getProperty(tableName);
            String newMeta = oldMeta + "," + colName + "," + colType;
            metadata.setProperty(tableName, newMeta);
            saveMetadata();  // 持久化更新后的表结构

            // 为已有记录添加新列的默认值
            List<Map<String, Object>> tableData = storage.get(tableName);
            for (Map<String, Object> row : tableData) {
                // INT类型默认0，其他类型（STRING）默认"DEFAULT"
                row.put(colName, "INT".equalsIgnoreCase(colType) ? 0 : "DEFAULT");
            }

            saveStorage();  // 持久化更新后的数据
            System.out.println("列添加成功: " + tableName);
        } else {
            throw new IllegalArgumentException("ALTER TABLE语法错误");
        }
    }

    /**
     * 处理 DELETE FROM：删除符合条件的记录（支持WHERE或删除所有）
     * 核心流程：
     * 1. 用正则解析SQL，提取表名和可选的WHERE条件
     * 2. 校验表是否存在
     * 3. 无WHERE条件：清空表中所有记录
     * 4. 有WHERE条件：解析条件（列名、运算符、值），筛选不匹配的记录保留
     * 5. 持久化删除后的数据
     */
    private void deleteData(String sql) {
        // 正则匹配"DELETE FROM 表名 [WHERE 条件]"
        // 分组1：表名；分组3：WHERE条件（可为null）
        Pattern pattern = Pattern.compile(
                "DELETE FROM (\\w+)( WHERE (.+))?",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);   // 表名
            String condition = matcher.group(3);   // WHERE条件（如"age>18"）

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表不存在: " + tableName);
            }

            List<Map<String, Object>> tableData = storage.get(tableName);
            if (condition == null) {
                // 无WHERE条件：删除所有记录
                tableData.clear();
            } else {
                // 解析WHERE条件：提取列名、运算符、值
                Pattern condPattern = Pattern.compile(
                        "(\\w+)\\s*(=|<|>)\\s*(\\w+)",
                        Pattern.CASE_INSENSITIVE
                );
                Matcher condMatcher = condPattern.matcher(condition);

                if (!condMatcher.find()) {
                    throw new IllegalArgumentException("非法条件: " + condition);
                }

                String colName = condMatcher.group(1);     // 条件列名（如"age"）
                String operator = condMatcher.group(2);   // 运算符（如">"）
                String condVal = condMatcher.group(3).replaceAll("^'|'$", "");  // 条件值（如"18"）

                // 筛选不删除的记录（避免边遍历边删导致异常）
                List<Map<String, Object>> newData = new ArrayList<>();
                for (Map<String, Object> row : tableData) {
                    Object rowVal = row.get(colName);  // 当前记录的条件列值
                    boolean match = false;  // 是否匹配条件（匹配则删除）

                    // 分类型比较（INT比较数字，STRING比较字符串）
                    if (rowVal instanceof Integer) {
                        int rowInt = (Integer) rowVal;
                        int condInt = Integer.parseInt(condVal);
                        switch (operator) {
                            case "=":
                                match = (rowInt == condInt);
                                break;
                            case "<":
                                match = (rowInt < condInt);
                                break;
                            case ">":
                                match = (rowInt > condInt);
                                break;
                        }
                    } else {
                        String rowStr = (String) rowVal;
                        match = switch (operator) {
                            case "=" -> rowStr.equals(condVal);
                            case "<" -> rowStr.compareTo(condVal) < 0;
                            case ">" -> rowStr.compareTo(condVal) > 0;
                            default -> false;
                        };
                    }

                    // 不匹配条件的记录保留
                    if (!match) {
                        newData.add(row);
                    }
                }
                // 用新列表替换原数据（完成删除）
                storage.put(tableName, newData);
            }

            saveStorage();  // 持久化删除后的数据
            System.out.println("数据删除成功: " + tableName);
        } else {
            throw new IllegalArgumentException("DELETE语法错误");
        }
    }

    /**
     * 处理UPDATE：更新符合条件的记录（支持WHERE或更新所有）
     * 核心流程：
     * 1. 用正则解析SQL，提取表名、更新列名、新值、可选WHERE条件
     * 2. 校验表和列是否存在，新值类型是否匹配列类型
     * 3. 无WHERE条件：更新所有记录的该列
     * 4. 有WHERE条件：解析条件，匹配的记录更新列值
     * 5. 持久化更新后的数据
     */
    private void updateData(String sql) {
        // 正则匹配"UPDATE 表名 SET 列名=值 [WHERE 条件]"
        Pattern pattern = Pattern.compile(
                "UPDATE\\s+(\\w+)\\s+SET\\s+(\\w+)\\s*=\\s*(\\d+|'[^']*')(?:\\s+WHERE\\s+(.+))?;?",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1).trim();  // 表名
            String colName = matcher.group(2).trim();    // 要更新的列名
            String rawNewValue = matcher.group(3);       // 新值（可能带单引号）

            // 校验新值不为空
            if (rawNewValue == null || rawNewValue.trim().isEmpty()) {
                throw new IllegalArgumentException("更新失败：新值不能为空");
            }
            String newValue = rawNewValue.trim().replaceAll("^'|'$", "");  // 去除单引号

            // 处理WHERE条件（可能为null）
            String condition = matcher.group(4);
            if (condition != null) {
                condition = condition.trim().replaceAll(";$", "");  // 去除末尾分号
                if (condition.isEmpty()) {
                    throw new IllegalArgumentException("更新失败：WHERE子句缺少条件");
                }
            }

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("更新失败：表不存在 - " + tableName);
            }

            // 校验：列是否存在并获取列类型
            String[] columnDefs = metadata.getProperty(tableName).split(",");
            boolean colExists = false;
            String colType = "";
            for (int i = 0; i < columnDefs.length; i += 2) {
                if (columnDefs[i].equals(colName)) {
                    colExists = true;
                    colType = columnDefs[i + 1].trim();
                    break;
                }
            }
            if (!colExists) {
                throw new IllegalArgumentException("更新失败：列不存在 - " + colName);
            }

            // 转换新值为列定义的类型
            Object convertedValue;
            try {
                convertedValue = convertValue(newValue, colType);
            } catch (RuntimeException e) {
                throw new IllegalArgumentException("更新失败：新值类型不匹配 - " + e.getMessage());
            }

            List<Map<String, Object>> tableData = storage.get(tableName);
            if (condition == null) {
                // 无WHERE条件：更新所有记录
                for (Map<String, Object> row : tableData) {
                    row.put(colName, convertedValue);
                }
            } else {
                // 解析WHERE条件
                Pattern condPattern = Pattern.compile(
                        "(\\w+)\\s*(=|<|>)\\s*('.*?'|\\d+|\\w+)",
                        Pattern.CASE_INSENSITIVE
                );
                Matcher condMatcher = condPattern.matcher(condition);

                if (!condMatcher.find()) {
                    throw new IllegalArgumentException("更新失败：条件格式错误 - " + condition);
                }

                String condCol = condMatcher.group(1).trim();    // 条件列名
                String operator = condMatcher.group(2).trim();   // 运算符
                String condVal = condMatcher.group(3).trim().replaceAll("^'|'$", "");  // 条件值

                // 遍历记录，匹配条件则更新
                for (Map<String, Object> row : tableData) {
                    Object rowVal = row.get(condCol);  // 当前记录的条件列值
                    if (rowVal == null) continue;

                    boolean match = false;  // 是否匹配条件
                    if (rowVal instanceof Integer) {
                        try {
                            int rowInt = (Integer) rowVal;
                            int condInt = Integer.parseInt(condVal);
                            switch (operator) {
                                case "=":
                                    match = (rowInt == condInt);
                                    break;
                                case "<":
                                    match = (rowInt < condInt);
                                    break;
                                case ">":
                                    match = (rowInt > condInt);
                                    break;
                            }
                        } catch (NumberFormatException e) {
                            match = false;
                        }
                    } else {
                        String rowStr = rowVal.toString();
                        switch (operator) {
                            case "=":
                                match = rowStr.equals(condVal);
                                break;
                            case "<":
                                match = rowStr.compareTo(condVal) < 0;
                                break;
                            case ">":
                                match = rowStr.compareTo(condVal) > 0;
                                break;
                        }
                    }

                    if (match) {  // 匹配条件→更新列值
                        row.put(colName, convertedValue);
                    }
                }
            }

            saveStorage();  // 持久化更新后的数据
            System.out.println("数据更新成功: " + tableName);
        } else {
            throw new IllegalArgumentException(
                    "UPDATE语法错误（正确示例：\n1. UPDATE student SET age=18;\n2. UPDATE student SET name='张三' WHERE id=1;）"
            );
        }
    }

    /**
     * 处理DROP TABLE：删除表（结构+数据+文件）
     * 核心流程：
     * 1. 用正则解析SQL，提取表名
     * 2. 校验表是否存在
     * 3. 从内存删除表结构和数据
     * 4. 删除磁盘上的表数据文件
     */
    private void dropTable(String sql) {
        // 正则匹配"DROP TABLE 表名"
        Pattern pattern = Pattern.compile(
                "DROP TABLE (\\w+)",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);   // 表名

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表不存在: " + tableName);
            }

            // 从元数据删除表结构
            metadata.remove(tableName);
            // 从内存删除表数据
            storage.remove(tableName);
            // 删除磁盘上的数据文件（data/表名.dat）
            new File(DATA_DIR, tableName + ".dat").delete();

            System.out.println("表删除成功: " + tableName);
        } else {
            throw new IllegalArgumentException("DROP TABLE语法错误");
        }
    }

    /**
     * 处理SELECT * FROM：显示表结构和所有数据
     * 核心流程：
     * 1. 用正则解析SQL，提取表名
     * 2. 校验表是否存在
     * 3. 打印表结构（列名+类型）
     * 4. 打印表中所有记录（按列顺序拼接值）
     */
    private void displayTable(String sql) {
        // 正则匹配"SELECT * FROM 表名"
        Pattern pattern = Pattern.compile(
                "SELECT \\* FROM (\\w+)",
                Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = pattern.matcher(sql);

        if (matcher.find()) {
            String tableName = matcher.group(1);   // 表名

            // 校验：表不存在则抛异常
            if (!metadata.containsKey(tableName)) {
                throw new IllegalArgumentException("表不存在: " + tableName);
            }

            // 显示表结构
            System.out.println("=== 表结构 ===");
            String[] columns = metadata.getProperty(tableName).split(",");
            for (int i = 0; i < columns.length; i += 2) {
                // 按"列名 (类型)"格式打印（如"id (INT)"）
                System.out.println(columns[i] + " (" + columns[i + 1] + ")");
            }

            // 显示表数据
            System.out.println("\n=== 表数据 ===");
            List<Map<String, Object>> tableData = storage.get(tableName);
            if (tableData.isEmpty()) {
                System.out.println("表中无数据");
                return;
            }

            // 遍历所有记录，按列顺序拼接值
            for (Map<String, Object> row : tableData) {
                List<String> values = new ArrayList<>();
                for (int i = 0; i < columns.length; i += 2) {
                    values.add(row.get(columns[i]).toString());
                }
                System.out.println(String.join(", ", values));
            }
        } else {
            throw new IllegalArgumentException("SELECT语法错误");
        }
    }

    /**
     * 处理SHOW TABLES：显示所有表名
     * 核心流程：
     * 1. 从元数据获取所有表名（metadata的key集合）
     * 2. 无表则提示，有表则逐个打印表名
     */
    private void showAllTables() {
        System.out.println("=== 所有表 ===");
        Set<String> tableNames = metadata.stringPropertyNames();
        if (tableNames.isEmpty()) {
            System.out.println("数据库中无表");
            return;
        }
        // 遍历打印所有表名
        for (String table : tableNames) {
            System.out.println(table);
        }
    }
}